package com.hzsoft.util;

import java.io.UnsupportedEncodingException;
import java.util.Random;



/**
 * 该类实现字符串的一些简单操作
 * 
 * @author CCRS项目组
 */
public class StringUtil {

	/** 在字符串左侧补齐空格 */
	public final static int LEFT_SPACE = 0;

	/** 在字符串右侧补齐空格 */
	public final static int RIGHT_SPACE = 1;

	/** 如果字符串实际长度超出指定长度，将左侧截断 */
	public final static int TRUNC_LEFT = 0;

	/** 如果字符串实际长度超出指定长度，将右侧截断 */
	public final static int TRUNC_RIGHT = 1;

	/**
	 * 该方法去掉字符串的左边空格
	 * @param String 需要去掉左边空格的字符串
	 * @return String 已经去掉左边空格的字符串
	 */
	public static String leftTrim(String str) {
		if (str == null) {
			return "";
		}

		byte[] bytes = str.getBytes();
		int index = 0;
		byte ch;
		do {
			ch = bytes[index];
			if (ch != ' ') {
				break;
			}
			index++;
		} while (true);
		return str.substring(index);
	}

	/**
	 * 改方法去掉字符串的右边空格
	 * 
	 * @param String
	 *            需要去掉右边空格的字符串
	 * @return String 已经去掉右边空格的字符串
	 */
	// duan_wliang update 2004-05-17
	public static String rightTrim(String str) {
		if (str == null) {
			return "";
		}

		byte[] bytes = str.getBytes();
		int index = StringUtil.length(str);

		if (index == 0) {
			return "";
		}

		index = index - 1;
		byte ch;
		do {
			ch = bytes[index];
			if (ch != ' ') {
				break;
			}
			index--;
		} while (index >= 0);

		return new String(str.getBytes(), 0, index + 1);
	}

	/**
	 * 
	 * 将字符串中所有的空格删除，包括左边、右边、中间。
	 * 
	 * @param str
	 */
	public static String allTrim(String str) {
		if (str == null) {
			return "";
		}
		String tmp = str.trim();
		if (tmp.equals("")) {
			return "";
		}
		int idx = 0;
		int len = 0;
		len = tmp.length();
		idx = tmp.indexOf(" ");
		while (idx > 0) {
			tmp = tmp.substring(0, idx) + tmp.substring(idx + 1, len);
			idx = tmp.indexOf(" ");
			len = tmp.length();
		}

		return tmp;
	}

	/**
	 * 该方法首先判断传入的字符串是否是null,如果是null则返回"",否则对传入的字符串执行trim操作后返回trim的结果
	 * 
	 * @param String
	 *            需要进行处理的字符串
	 * @return String 处理完成的结果字符串
	 */
	public static String trim(String orin) {
		if (orin == null) {
			orin = "";
		}
		return orin.trim();
	}

	/**
	 * 该方法将传入的字符串扩充为指定长度的字符串,长度不足的话,补充空格 如果字符串长度大于指定的长度,就截断超出的那部分字符.
	 * 
	 * @param str
	 *            需要处理的字符串
	 * @param len
	 *            指定的字符串长度
	 * @param direct
	 *            StringUtil.LEFT_SPACE 从左侧补充空格 StringUtil.RIGHT_SPACE 从右侧补充空格
	 * @param truncWay
	 *            StringUtil.TRUNC_LEFT 从左侧截断空格 StringUtil.TRUNC_RIGHT 从右侧截断空格
	 * @return 返回指定格式的字符串
	 */
	public static String alignStr(String str, int len, int direct, int truncWay) {

		return alignStr(str, len, direct, truncWay, ' ');

	}

	/**
	 * 该方法将传入的字符串扩充为指定长度的字符串,长度不足的话,以 fixStr 补充 如果字符串长度大于指定的长度,就截断超出的那部分字符.
	 * 
	 * @param str
	 *            需要处理的字符串
	 * @param len
	 *            指定的字符串长度
	 * @param direct
	 *            StringUtil.LEFT_SPACE 从左侧补充空格 StringUtil.RIGHT_SPACE 从右侧补充空格
	 * @param truncWay
	 *            StringUtil.TRUNC_LEFT 从左侧截断空格 StringUtil.TRUNC_RIGHT 从右侧截断空格
	 * @param fixStr
	 *            用来填充的的字符
	 * @return 返回指定格式的字符串
	 */
	public static String alignStr(String str, int len, int direct,
			int truncWay, char fixStr) {

		/*
		 * if (str == null) return "";
		 * 
		 * int l = length(str); if (l >= len) { if (truncWay ==
		 * StringUtil.TRUNC_LEFT) return str.substring(l - len, l); else return
		 * str.substring(0, len); }
		 * 
		 * StringBuffer sb = new StringBuffer(str); for (int i = l; i < len;
		 * i++) { if (direct == StringUtil.RIGHT_SPACE) sb = sb.insert(0,
		 * fixStr); else sb = sb.append(fixStr); } return sb.substring(0);
		 */
		if (str == null) {
			return "";
		}

		byte[] b = StringUtil.getBytes(str);
		int l = StringUtil.length(str);
		if (l >= len) {
			if (truncWay == StringUtil.TRUNC_LEFT) {
				return new String(b, l - len, len);
			} else
				return new String(b, 0, len);
		}

		StringBuffer sb = new StringBuffer(str);
		for (int i = l; i < len; i++) {
			if (direct == StringUtil.LEFT_SPACE) {
				sb = sb.insert(0, fixStr);
			} else
				sb = sb.append(fixStr);
		}
		return sb.substring(0);
	}

	/**
	 * 该方法计算字符串(包括中文)的实际长度.
	 * 
	 * @param str
	 *            需要计算长度的字符串
	 * @return int 字符串的实际长度
	 */
	public static int length(String str) {

		if (str == null) {
			return 0;
		}
		try {
			return new String(str.getBytes("GBK"), "8859_1").length();
		} catch (UnsupportedEncodingException e) {
			return -1;
		}
	}

	/**
	 * 
	 */
	public static byte[] getBytes(String str) {
		try {
			return str.getBytes("GBK");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			return "".getBytes();
		}
	}

	public static String toString(Object in) {
		if (in == null) {
			return "";
		}

		return in.toString();
	}
	

	/**
	 * 倒序
	 * 
	 * @param str
	 * @return
	 */
	public static String recoverStr(String str) {
		char[] mm = str.toCharArray();
		String temp = "";
		for (int i = mm.length - 1; i >= 0; i--) {
			temp = temp + mm[i];
		}
		return temp;
	}

	public static String replace(String in, String oldStr, String newStr,
			int begin, int end) {
		if (begin < 0) {
			begin = 0;
		} else if (begin > in.length()) {
			begin = in.length();
		}
		if (end < 0) {
			end = 0;
		} else if (end > in.length()) {
			end = in.length();
		}
	
		String temp1 = in.substring(begin, end);

		String temp2 = in.substring(0, begin);

		String temp3 = in.substring(end, in.length());

		return temp2 + temp1.replaceAll(oldStr, newStr) + temp3;
	}
	
	/**
	   * 产生随机字符串
	   * */
	private static Random randGen = null;
	private static char[] numbersAndLetters = null;

	public static final String randomString(int length) {
	         if (length < 1) {
	             return null;
	         }
	         if (randGen == null) {
	                randGen = new Random();
	                numbersAndLetters = ("0123456789abcdefghijklmnopqrstuvwxyz" +
	                   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();
	                  //numbersAndLetters = ("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();
	                 }
	         char [] randBuffer = new char[length];
	         for (int i=0; i<randBuffer.length; i++) {
	             randBuffer[i] = numbersAndLetters[randGen.nextInt(71)];
	          //randBuffer[i] = numbersAndLetters[randGen.nextInt(35)];
	         }
	         return new String(randBuffer);
	}
	
	//调用此方法randomString(int),int是字符串的长度，即可产生指定长度的随机字符串
	
}